home *** CD-ROM | disk | FTP | other *** search
/ Greenhouse Effect Detection Expriment / NASA Greenhouse Effect Detection Expriment 1992 - Disc 2.iso / software / dos / cdf22pc / src / lib / cdf_f_if.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-29  |  44.8 KB  |  1,478 lines
  1. /******************************************************************************
  2. *
  3. *  NSSDC/CDF                        CDF FORTRAN interface.
  4. *
  5. *  Version 2.2, 29-Feb-92, ST Systems (STX)
  6. *
  7. *  Modification history:
  8. *
  9. *   V1.0  22-Jan-91, J Love    Original version (for CDF V2.0).
  10. *   V1.1  11-Feb-91, J Love    Fixed max_rec in CDF_inquire.
  11. *   V2.0   1-Jun-91, J Love    Renamed (was CDF_V2_FORTRAN_IF.C).  Changed
  12. *                for new CDF V2.1 internal structures.  Also
  13. *                calls INTERNAL i/f directly rather than using
  14. *                C i/f.
  15. *   V2.1  30-Jul-91, J Love    Use 'CDFlib'.  If variable data type is CHAR
  16. *                or UCHAR, check for %DESCR (if VMS).
  17. *   V2.2  29-Feb-92, J Love    Modified for IBM-PC port.  CDF V2.2.
  18. *
  19. ******************************************************************************/
  20.  
  21. /******************************************************************************
  22. *
  23. *  Notes (for VMS version):
  24. *
  25. *    To make the user's life a little easier, all names and attribute
  26. *  values (for attributes of data types CDF_CHAR and CDF_UCHAR) may be passed
  27. *  in and out by either reference or descriptor.  The default passing mode
  28. *  for an embedded character string (e.g., CALL subr (..., 'string', ...)) or
  29. *  a CHARACTER variable symbol (e.g., CALL subr (..., ATTR_NAME, ...) where
  30. *  ATTR_NAME is defined as CHARACTER*8) is by descriptor when passing from
  31. *  FORTRAN to C in VMS.
  32. *
  33. *    An embedded character string could be enclosed in %REF() to force
  34. *  passing by reference since the FORTRAN compiler puts a NUL character at
  35. *  the end of these strings as expected by the CDF V2.0 library (written in
  36. *  C).  Enclosing a CHARACTER variable symbol in %REF() will result in
  37. *  an error, however, because a NUL character is not placed at the ends of
  38. *  these type strings by the FORTRAN compiler.  The user would have to
  39. *  supply the terminating NUL.  By letting the passing mode default to
  40. *  by-descriptor, this interface will supply the terminating NUL.
  41. *
  42. *    The main difference here from CDF Version 1 is that the %REF() is
  43. *  not needed when passing out names and attribute values.  Also, variable
  44. *  values for character variables need not be enclosed in %REF().
  45. *
  46. ******************************************************************************/
  47.  
  48. /******************************************************************************
  49. *
  50. *  Notes (for UNIX version):
  51. *
  52. *    All passing between FORTRAN and C on UNIX systems is done by reference.
  53. *  When character strings are passed between FORTRAN and C, extra arguments
  54. *  are added to the argument list containing the lengths of those character
  55. *  strings.
  56. *
  57. *    Entry points have been made lowercase because the FORTRAN compiler
  58. *  converts all uppercase characters to lowercase in entry points.  This way
  59. *  the linker will find everything.  Unix FORTRAN compilers and linkers also
  60. *  seem to like trailing '_'s (except on the IBM-RS6000/AIX).
  61. *
  62. ******************************************************************************/
  63.  
  64. #include "cdflib.h"
  65.  
  66.  
  67. /******************************************************************************
  68. *  CDF_create.
  69. ******************************************************************************/
  70.  
  71. #if defined(vms)
  72. void CDF_create (CDF_name, num_dims, dim_sizes, encoding, majority, id, Status)
  73. void      *CDF_name;        /* in: CDF name
  74.                           - in VMS, may be passed by
  75.                      reference or descriptor */
  76. long      *num_dims;        /* in: number of dimensions */
  77. long      dim_sizes[];        /* in: dimension sizes */
  78. long      *encoding;        /* in: host or network */
  79. long      *majority;        /* in: row or column major */
  80. CDFid      *id;            /* out: CDF identifier */
  81. CDFstatus *Status;        /* out: CDF status code */
  82. {
  83. *Status = CDFlib (CREATE_, CDF_, DESCRtoREFnul(CDF_name,CDF_PATHNAME_LEN),
  84.                  *num_dims, dim_sizes, id,
  85.           PUT_, CDF_ENCODING_, *encoding,
  86.             CDF_MAJORITY_, *majority,
  87.           NULL_);
  88. return;
  89. }
  90. #endif
  91.  
  92. /*****************************************************************************/
  93.  
  94. #if defined(unix)
  95. #if defined(AIX)
  96. void cdf_create (CDF_name, num_dims, dim_sizes, encoding, majority, id,
  97.           Status, CDF_name_len)
  98. #else
  99. void cdf_create_ (CDF_name, num_dims, dim_sizes, encoding, majority, id,
  100.           Status, CDF_name_len)
  101. #endif
  102. char      *CDF_name;        /* in: CDF name */
  103. long      *num_dims;        /* in: number of dimensions */
  104. long      dim_sizes[];        /* in: dimension sizes */
  105. long      *encoding;        /* in: host or network */
  106. long      *majority;        /* in: row or column major */
  107. CDFid      *id;            /* out: CDF identifier */
  108. CDFstatus *Status;        /* out: CDF status code */
  109. long      CDF_name_len;        /* invisible: length of "CDF_name"
  110.                    (generated by FORTRAN compiler) */
  111. {
  112. *Status = CDFlib (CREATE_, CDF_, NULterminate(CDF_name,CDF_name_len),
  113.                  *num_dims, dim_sizes, id,
  114.           PUT_, CDF_ENCODING_, *encoding,
  115.             CDF_MAJORITY_, *majority,
  116.           NULL_);
  117. return;
  118. }
  119. #endif
  120.  
  121.  
  122. /******************************************************************************
  123. *  CDF_open.
  124. ******************************************************************************/
  125.  
  126. #if defined(vms)
  127. void CDF_open (CDF_name, id, Status)
  128. void      *CDF_name;        /* in: CDF name
  129.                    - in VMS, may be passed by
  130.                      reference or descriptor */
  131. CDFid      *id;            /* out: CDF identifier */
  132. CDFstatus *Status;        /* out: CDF status code */
  133. {
  134. *Status = CDFlib (OPEN_, CDF_, DESCRtoREFnul(CDF_name,CDF_PATHNAME_LEN),
  135.                    id,
  136.           NULL_);
  137. return;
  138. }
  139. #endif
  140.  
  141. /*****************************************************************************/
  142.  
  143. #if defined(unix)
  144. #if defined(AIX)
  145. void cdf_open (CDF_name, id, Status, CDF_name_len)
  146. #else
  147. void cdf_open_ (CDF_name, id, Status, CDF_name_len)
  148. #endif
  149. char      *CDF_name;        /* in: CDF name */
  150. CDFid      *id;            /* out: CDF identifier */
  151. CDFstatus *Status;        /* out: CDF status code */
  152. long      CDF_name_len;        /* invisible: length of "CDF_name"
  153.                    (generated by FORTRAN compiler) */
  154. {
  155. *Status = CDFlib (OPEN_, CDF_, NULterminate(CDF_name,CDF_name_len),
  156.                    id,
  157.           NULL_);
  158. return;
  159. }
  160. #endif
  161.  
  162.  
  163. /******************************************************************************
  164. *  CDF_doc.
  165. ******************************************************************************/
  166.  
  167. #if defined(vms)
  168. void CDF_doc (id, version, release, text, Status)
  169. CDFid      *id;            /* in: CDF identifier */
  170. long      *version;        /* out: CDF version number (creating library
  171.                     version number) */
  172. long      *release;        /* out: CDF release number (creating library
  173.                     release number) */
  174. void      *text;        /* out: copyright text - passed by
  175.                     reference or descriptor */
  176. CDFstatus *Status;        /* out: CDF status code */
  177. {
  178. char    copyrightText[CDF_COPYRIGHT_LEN + 1];
  179.  
  180. *Status = CDFlib (SELECT_, CDF_, *id,
  181.           GET_, CDF_VERSION_, version,
  182.               CDF_RELEASE_, release,
  183.               CDF_COPYRIGHT_, copyrightText,
  184.           NULL_);
  185. if (*Status > CDF_WARN) CtoFORTstring (copyrightText, text, CDF_COPYRIGHT_LEN);
  186.  
  187. return;
  188. }
  189. #endif
  190.  
  191. /*****************************************************************************/
  192.  
  193. #if defined(unix)
  194. #if defined(AIX)
  195. void cdf_doc (id, version, release, text, Status, text_len)
  196. #else
  197. void cdf_doc_ (id, version, release, text, Status, text_len)
  198. #endif
  199. CDFid      *id;            /* in: CDF identifier */
  200. long      *version;        /* out: CDF version number (creating library
  201.                     version number) */
  202. long      *release;        /* out: CDF release number (creating library
  203.                     release number) */
  204. char      *text;        /* out: copyright text */
  205. CDFstatus *Status;        /* out: CDF status code */
  206. long      text_len;        /* invisible: length of "text"
  207.                    (generated by FORTRAN compiler) */
  208. {
  209. char    copyrightText[CDF_COPYRIGHT_LEN + 1];
  210.  
  211. *Status = CDFlib (SELECT_, CDF_, *id,
  212.           GET_, CDF_VERSION_, version,
  213.               CDF_RELEASE_, release,
  214.               CDF_COPYRIGHT_, copyrightText,
  215.           NULL_);
  216. if (*Status > CDF_WARN) CtoFORTstring (copyrightText, text, text_len);
  217.  
  218. return;
  219. }
  220. #endif
  221.  
  222.  
  223. /******************************************************************************
  224. *  CDF_inquire.
  225. ******************************************************************************/
  226.  
  227. #if defined(vms)
  228. void CDF_inquire (id, num_dims, dim_sizes, encoding, majority,
  229.           max_rec, num_vars, num_attrs, Status)
  230. #endif
  231.  
  232. #if defined(unix)
  233. #if defined(AIX)
  234. void cdf_inquire (id, num_dims, dim_sizes, encoding, majority,
  235.           max_rec, num_vars, num_attrs, Status)
  236. #else
  237. void cdf_inquire_ (id, num_dims, dim_sizes, encoding, majority,
  238.            max_rec, num_vars, num_attrs, Status)
  239. #endif
  240. #endif
  241.  
  242. CDFid      *id;            /* in: CDF identifier */
  243. long      *num_dims;        /* out: number of dimensions */
  244. long      dim_sizes[];        /* out: dimension sizes */
  245. long      *encoding;        /* out: host or network */
  246. long      *majority;        /* out: row or column major */
  247. long      *max_rec;        /* out: maximum record number */
  248. long      *num_vars;        /* out: number of variables */
  249. long      *num_attrs;        /* out: number of attributes */
  250. CDFstatus *Status;        /* out: CDF status code */
  251. {
  252. long    maxRec;
  253.  
  254. *Status = CDFlib (SELECT_, CDF_, *id,
  255.           GET_, CDF_NUMDIMS_, num_dims,
  256.                   CDF_DIMSIZES_, dim_sizes,
  257.                 CDF_ENCODING_, encoding,
  258.                   CDF_MAJORITY_, majority,
  259.                   CDF_MAXREC_, &maxRec,
  260.                   CDF_NUMVARS_, num_vars,
  261.                   CDF_NUMATTRS_, num_attrs,
  262.           NULL_);
  263. *max_rec = maxRec + 1;
  264.  
  265. return;
  266. }
  267.  
  268.  
  269. /******************************************************************************
  270. *  CDF_close.
  271. ******************************************************************************/
  272.  
  273. #if defined(vms)
  274. void CDF_close (id, Status)
  275. #endif
  276.  
  277. #if defined(unix)
  278. #if defined(AIX)
  279. void cdf_close (id, Status)
  280. #else
  281. void cdf_close_ (id, Status)
  282. #endif
  283. #endif
  284.  
  285. CDFid      *id;            /* in: CDF identifier */
  286. CDFstatus *Status;        /* out: CDF status code */
  287. {
  288. *Status = CDFlib (SELECT_, CDF_, *id,
  289.           CLOSE_, CDF_,
  290.           NULL_);
  291. return;
  292. }
  293.  
  294.  
  295. /******************************************************************************
  296. *  CDF_delete.
  297. ******************************************************************************/
  298.  
  299. #if defined(vms)
  300. void CDF_delete (id, Status)
  301. #endif
  302.  
  303. #if defined(unix)
  304. #if defined(AIX)
  305. void cdf_delete (id, Status)
  306. #else
  307. void cdf_delete_ (id, Status)
  308. #endif
  309. #endif
  310.  
  311. CDFid      *id;            /* in: CDF identifier */
  312. CDFstatus *Status;        /* out: CDF status code */
  313. {
  314. *Status = CDFlib (SELECT_, CDF_, *id,
  315.           DELETE_, CDF_,
  316.           NULL_);
  317. return;
  318. }
  319.  
  320.  
  321. /******************************************************************************
  322. *  CDF_attr_create.
  323. ******************************************************************************/
  324.  
  325. #if defined(vms)
  326. void CDF_attr_create (id, attr_name, attr_scope, attr_num, Status)
  327. CDFid      *id;               /* in: CDF identifier */
  328. void      *attr_name;           /* in: attribute name
  329.                        - in VMS, may be passed by
  330.                      reference or descriptor */
  331. long      *attr_scope;           /* in: VARIABLE, GLOBAL, ASSUMED_VARIABLE,
  332.                        or ASSUMED_GLOBAL */
  333. long      *attr_num;           /* out: attribute number */
  334. CDFstatus *Status;        /* out: CDF status code */
  335. {
  336.  
  337. long    attrNum;    /* indexed from 0 (V2/C style) */
  338.  
  339. *Status = CDFlib (SELECT_, CDF_, *id,
  340.           CREATE_, ATTR_, DESCRtoREFnul(attr_name,
  341.                         CDF_ATTR_NAME_LEN),
  342.                    *attr_scope, &attrNum,
  343.           NULL_);
  344. *attr_num = attrNum + 1;    /* attr_num indexed from 1 (FORTRAN style) */
  345.  
  346. return;
  347. }
  348. #endif
  349.  
  350. /*****************************************************************************/
  351.  
  352. #if defined(unix)
  353. #if defined(AIX)
  354. void cdf_attr_create (id, attr_name, attr_scope, attr_num, Status,
  355.               attr_name_len)
  356. #else
  357. void cdf_attr_create_ (id, attr_name, attr_scope, attr_num, Status,
  358.                attr_name_len)
  359. #endif
  360. CDFid      *id;               /* in: CDF identifier */
  361. char      *attr_name;           /* in: attribute name */
  362. long      *attr_scope;           /* in: VARIABLE, GLOBAL, ASSUMED_VARIABLE,
  363.                        or ASSUMED_GLOBAL */
  364. long      *attr_num;           /* out: attribute number */
  365. CDFstatus *Status;        /* out: CDF status code */
  366. long      attr_name_len;    /* invisible: length of "attr_name"
  367.                    (generated by FORTRAN compiler) */
  368. {
  369. long    attrNum;    /* indexed from 0 (V2/C style) */
  370.  
  371. *Status = CDFlib (SELECT_, CDF_, *id,
  372.           CREATE_, ATTR_, NULterminate(attr_name, attr_name_len),
  373.                    *attr_scope, &attrNum,
  374.           NULL_);
  375. *attr_num = attrNum + 1;    /* attr_num indexed from 1 (FORTRAN style) */
  376.  
  377. return;
  378. }
  379. #endif
  380.  
  381.  
  382. /******************************************************************************
  383. *  CDF_attr_num.
  384. ******************************************************************************/
  385.  
  386. #if defined(vms)
  387. long CDF_attr_num (id, attr_name)
  388. CDFid     *id;               /* in: CDF identifier */
  389. void      *attr_name;           /* in: attribute name
  390.                        - in VMS, may be passed by
  391.                      reference or descriptor */
  392. {
  393. CDFstatus status;
  394. long      attrNum;
  395.  
  396. status = CDFlib (SELECT_, CDF_, *id,
  397.          GET_, ATTR_NUMBER_, DESCRtoREFnul(attr_name,
  398.                            CDF_ATTR_NAME_LEN),
  399.                  &attrNum,
  400.          NULL_);
  401. if (status < CDF_WARN)
  402.   return status;
  403. else
  404.   return attrNum + 1;        /* +1 for FORTRAN i/f (assuming no INFO status
  405.                    codes returned) */
  406. }
  407. #endif
  408.  
  409. /*****************************************************************************/
  410.  
  411. #if defined(unix)
  412. #if defined(AIX)
  413. long cdf_attr_num (id, attr_name, attr_name_len)
  414. #else
  415. long cdf_attr_num_ (id, attr_name, attr_name_len)
  416. #endif
  417. CDFid     *id;               /* in: CDF identifier */
  418. char      *attr_name;           /* in: attribute name */
  419. long      attr_name_len;    /* invisible: length of "attr_name"
  420.                    (generated by FORTRAN compiler) */
  421. {
  422. CDFstatus status;
  423. long      attrNum;
  424.  
  425. status = CDFlib (SELECT_, CDF_, *id,
  426.          GET_, ATTR_NUMBER_, NULterminate(attr_name, attr_name_len),
  427.                  &attrNum,
  428.          NULL_);
  429. if (status < CDF_WARN)
  430.   return status;
  431. else
  432.   return attrNum + 1;        /* +1 for FORTRAN i/f (assuming no INFO status
  433.                    codes returned) */
  434. }
  435. #endif
  436.  
  437.  
  438. /******************************************************************************
  439. *  CDF_attr_rename.
  440. ******************************************************************************/
  441.  
  442. #if defined(vms)
  443. void CDF_attr_rename (id, attr_num, attr_name, Status)
  444. CDFid     *id;               /* in: CDF identifier */
  445. long      *attr_num;           /* in: attribute number, indexed from 1
  446.                        (FORTRAN style) */
  447. void      *attr_name;           /* in: new attribute name
  448.                        - in VMS, may be passed by
  449.                      reference or descriptor */
  450. CDFstatus *Status;        /* out: CDF status code */
  451. {
  452. *Status = CDFlib (SELECT_, CDF_, *id,
  453.                ATTR_, *attr_num - 1,
  454.           PUT_, ATTR_NAME_, DESCRtoREFnul(attr_name,
  455.                          CDF_ATTR_NAME_LEN),
  456.           NULL_);
  457. return;
  458. }
  459. #endif
  460.  
  461. /*****************************************************************************/
  462.  
  463. #if defined(unix)
  464. #if defined(AIX)
  465. void cdf_attr_rename (id, attr_num, attr_name, Status, attr_name_len)
  466. #else
  467. void cdf_attr_rename_ (id, attr_num, attr_name, Status, attr_name_len)
  468. #endif
  469. CDFid     *id;               /* in: CDF identifier */
  470. long      *attr_num;           /* in: attribute number, indexed from 1
  471.                        (FORTRAN style) */
  472. char      *attr_name;           /* in: new attribute name */
  473. CDFstatus *Status;        /* out: CDF status code */
  474. long      attr_name_len;    /* invisible: length of "attr_name"
  475.                    (generated by FORTRAN compiler) */
  476. {
  477.  
  478. *Status = CDFlib (SELECT_, CDF_, *id,
  479.                ATTR_, *attr_num - 1,
  480.           PUT_, ATTR_NAME_, NULterminate(attr_name, attr_name_len),
  481.           NULL_);
  482. return;
  483. }
  484. #endif
  485.  
  486.  
  487. /******************************************************************************
  488. *  CDF_attr_correct_scope.
  489. ******************************************************************************/
  490.  
  491. #if defined(vms)
  492. void CDF_attr_correct_scope (id, attr_num, attr_scope, Status)
  493. #endif
  494.  
  495. #if defined(unix)
  496. #if defined(AIX)
  497. void cdf_attr_correct_scope (id, attr_num, attr_scope, Status)
  498. #else
  499. void cdf_attr_correct_scope_ (id, attr_num, attr_scope, Status)
  500. #endif
  501. #endif
  502.  
  503. CDFid     *id;               /* in: CDF identifier */
  504. long      *attr_num;           /* in: attribute number, indexed from 1
  505.                        (FORTRAN style) */
  506. long      *attr_scope;           /* in: VARIABLE, GLOBAL, ASSUMED_VARIABLE,
  507.                        or ASSUMED_GLOBAL */
  508. CDFstatus *Status;        /* out: CDF status code */
  509. {
  510. *Status = CDFlib (SELECT_, CDF_, *id,
  511.                ATTR_, *attr_num-1,
  512.           PUT_, ATTR_SCOPE_, *attr_scope,
  513.           NULL_);
  514. return;
  515. }
  516.  
  517.  
  518. /******************************************************************************
  519. *  CDF_attr_inquire.
  520. ******************************************************************************/
  521.  
  522. #if defined(vms)
  523. void CDF_attr_inquire (id, attr_num, attr_name, attr_scope, max_entry, Status)
  524. CDFid      *id;               /* in: CDF identifier */
  525. long      *attr_num;           /* in: attribute number, indexed from 1
  526.                        (FORTRAN style) */
  527. void      *attr_name;          /* out: attribute name - passed out
  528.                     by reference or descriptor */
  529. long      *attr_scope;           /* out: VARIABLE, GLOBAL, ASSUMED_VARIABLE,
  530.                     or ASSUMED_GLOBAL */
  531. long      *max_entry;           /* out: maximum entry number for attribute */
  532. CDFstatus *Status;        /* out: CDF status code */
  533. {
  534. char    attrName[CDF_ATTR_NAME_LEN + 1];
  535. long    maxEntry;
  536.  
  537. *Status = CDFlib (SELECT_, CDF_, *id,
  538.                ATTR_, *attr_num - 1,
  539.           GET_, ATTR_NAME_, attrName,
  540.             ATTR_SCOPE_, attr_scope,
  541.             ATTR_MAXENTRY_, &maxEntry,
  542.           NULL_);
  543. if (*Status > CDF_WARN) {
  544.   CtoFORTstring (attrName, attr_name, CDF_ATTR_NAME_LEN);
  545.   *max_entry = maxEntry + 1;
  546. }
  547.  
  548. return;
  549. }
  550. #endif
  551.  
  552. /*****************************************************************************/
  553.  
  554. #if defined(unix)
  555. #if defined(AIX)
  556. void cdf_attr_inquire (id, attr_num, attr_name, attr_scope, max_entry,
  557.                Status, attr_name_len)
  558. #else
  559. void cdf_attr_inquire_ (id, attr_num, attr_name, attr_scope, max_entry,
  560.                 Status, attr_name_len)
  561. #endif
  562. CDFid      *id;               /* in: CDF identifier */
  563. long      *attr_num;           /* in: attribute number, indexed from 1
  564.                        (FORTRAN style) */
  565. char      *attr_name;          /* out: attribute name */
  566. long      *attr_scope;           /* out: VARIABLE, GLOBAL, ASSUMED_VARIABLE,
  567.                     or ASSUMED_GLOBAL */
  568. long      *max_entry;           /* out: maximum entry number for attribute */
  569. CDFstatus *Status;        /* out: CDF status code */
  570. long      attr_name_len;    /* invisible: length of "attr_name"
  571.                    (generated by FORTRAN compiler) */
  572. {
  573. char    attrName[CDF_ATTR_NAME_LEN + 1];
  574. long    maxEntry;
  575.  
  576. *Status = CDFlib (SELECT_, CDF_, *id,
  577.                ATTR_, *attr_num - 1,
  578.           GET_, ATTR_NAME_, attrName,
  579.             ATTR_SCOPE_, attr_scope,
  580.             ATTR_MAXENTRY_, &maxEntry,
  581.           NULL_);
  582. if (*Status > CDF_WARN) {
  583.   CtoFORTstring (attrName, attr_name, attr_name_len);
  584.   *max_entry = maxEntry + 1;
  585. }
  586.  
  587. return;
  588. }
  589. #endif
  590.  
  591.  
  592. /******************************************************************************
  593. *  CDF_attr_entry_inquire.
  594. ******************************************************************************/
  595.  
  596. #if defined(vms)
  597. void CDF_attr_entry_inquire (id, attr_num, entry_num, data_type, num_elements,
  598.                  Status)
  599. #endif
  600.  
  601. #if defined(unix)
  602. #if defined(AIX)
  603. void cdf_attr_entry_inquire (id, attr_num, entry_num, data_type, num_elements,
  604.                  Status)
  605. #else
  606. void cdf_attr_entry_inquire_ (id, attr_num, entry_num, data_type, num_elements,
  607.                   Status)
  608. #endif
  609. #endif
  610.  
  611. CDFid      *id;               /* in: CDF identifier */
  612. long      *attr_num;           /* in: attribute number, indexed from 1
  613.                        (FORTRAN style) */
  614. long      *entry_num;           /* in: entry number, indexed from 1
  615.                        (FORTRAN style) */
  616. long      *data_type;           /* out: CDF V2 style data type */
  617. long      *num_elements;       /* out: number of elements */
  618. CDFstatus *Status;        /* out: CDF status code */
  619. {
  620. *Status = CDFlib (SELECT_, CDF_, *id,
  621.                ATTR_, *attr_num - 1,
  622.                ENTRY_, *entry_num - 1,
  623.           GET_, ENTRY_DATATYPE_, data_type,
  624.             ENTRY_NUMELEMS_, num_elements,
  625.           NULL_);
  626. return;
  627. }
  628.  
  629.  
  630. /******************************************************************************
  631. *  CDF_attr_put.
  632. *
  633. *  UNIX: Note that one extra argument may be passed in if the "value" is of
  634. *     type CHARACTER.  The extra argument would be ignored in this case.
  635. *
  636. ******************************************************************************/
  637.  
  638. #if defined(vms)
  639. void CDF_attr_put (id, attr_num, entry_num, data_type, num_elements, value,
  640.            Status)
  641. CDFid      *id;               /* in: CDF identifier */
  642. long      *attr_num;           /* in: attribute number, indexed from 1
  643.                       (FORTRAN style) */
  644. long      *entry_num;           /* in: entry number, indexed from 1
  645.                       (FORTRAN style) */
  646. long      *data_type;           /* in: CDF V2 style data type */
  647. long      *num_elements;       /* in: number of elements */
  648. void      *value;           /* in: attribute value, if CDF_CHAR/CDF_UCHAR
  649.                        attribute, in VMS could be passed
  650.                        by reference or descriptor */
  651. CDFstatus *Status;        /* out: CDF status code */
  652. {
  653. *Status = CDFlib (SELECT_, CDF_, *id,
  654.                      ATTR_, *attr_num - 1,
  655.                ENTRY_, *entry_num - 1,
  656.           PUT_, ENTRY_DATA_, *data_type, *num_elements,
  657.                            (STRINGdataType(*data_type) ?
  658.                         DESCRtoREF(value) : value),
  659.           NULL_);
  660. return;
  661. }
  662. #endif
  663.  
  664. /*****************************************************************************/
  665.  
  666. #if defined(unix)
  667. #if defined(AIX)
  668. void cdf_attr_put (id, attr_num, entry_num, data_type, num_elements, value,
  669.            Status)
  670. #else
  671. void cdf_attr_put_ (id, attr_num, entry_num, data_type, num_elements, value,
  672.             Status)
  673. #endif
  674. CDFid      *id;               /* in: CDF identifier */
  675. long      *attr_num;           /* in: attribute number, indexed from 1
  676.                       (FORTRAN style) */
  677. long      *entry_num;           /* in: entry number, indexed from 1
  678.                       (FORTRAN style) */
  679. long      *data_type;           /* in: CDF V2 style data type */
  680. long      *num_elements;       /* in: number of elements */
  681. void      *value;           /* in: attribute value */
  682. CDFstatus *Status;        /* out: CDF status code */
  683. {
  684. *Status = CDFlib (SELECT_, CDF_, *id,
  685.                      ATTR_, *attr_num - 1,
  686.                ENTRY_, *entry_num - 1,
  687.           PUT_, ENTRY_DATA_, *data_type, *num_elements, value,
  688.           NULL_);
  689. return;
  690. }
  691. #endif
  692.  
  693.  
  694. /******************************************************************************
  695. *  CDF_attr_get.
  696. *
  697. *  UNIX: Note that one extra argument may be passed in if the "value" is of
  698. *     type CHARACTER.  The extra argument would be ignored in this case.
  699. *
  700. ******************************************************************************/
  701.  
  702. #if defined(vms)
  703. void CDF_attr_get (id, attr_num, entry_num, value, Status)
  704. CDFid      *id;               /* in: CDF identifier */
  705. long      *attr_num;           /* in: attribute number, indexed from 1
  706.                        (FORTRAN style) */
  707. long      *entry_num;           /* in: entry number, indexed from 1
  708.                        (FORTRAN style) */
  709. void      *value;           /* out: could be passed out by reference or
  710.                     by descriptor if CDF_CHAR/CDF_UCHAR */
  711. CDFstatus *Status;        /* out: CDF status code */
  712. {
  713. long    dataType;
  714.  
  715. *Status = CDFlib (SELECT_, CDF_, *id,
  716.                ATTR_, *attr_num - 1,
  717.                ENTRY_, *entry_num - 1,
  718.           GET_, ENTRY_DATATYPE_, &dataType,
  719.           NULL_);
  720.  
  721. if (*Status > CDF_WARN)
  722.   *Status = CDFlib (SELECT_, CDF_, *id,
  723.             GET_, ENTRY_DATA_, STRINGdataType(dataType) ?
  724.                        DESCRtoREF(value) : value,
  725.             NULL_);
  726.  
  727. return;
  728. }
  729. #endif
  730.  
  731. /*****************************************************************************/
  732.  
  733. #if defined(unix)
  734. #if defined(AIX)
  735. void cdf_attr_get (id, attr_num, entry_num, value, Status)
  736. #else
  737. void cdf_attr_get_ (id, attr_num, entry_num, value, Status)
  738. #endif
  739. CDFid      *id;               /* in: CDF identifier */
  740. long      *attr_num;           /* in: attribute number, indexed from 1
  741.                        (FORTRAN style) */
  742. long      *entry_num;           /* in: entry number, indexed from 1
  743.                        (FORTRAN style) */
  744. void      *value;           /* out: attribute value */
  745. CDFstatus *Status;        /* out: CDF status code */
  746. {
  747. *Status = CDFlib (SELECT_, CDF_, *id,
  748.                ATTR_, *attr_num - 1,
  749.                ENTRY_, *entry_num - 1,
  750.           GET_, ENTRY_DATA_, value,
  751.           NULL_);
  752. return;
  753. }
  754. #endif
  755.  
  756.  
  757. /******************************************************************************
  758. *  CDF_var_create.
  759. ******************************************************************************/
  760.  
  761. #if defined(vms)
  762. void CDF_var_create (id, var_name, data_type, num_elements, record_variance,
  763.              dim_variances, var_num, Status)
  764. CDFid      *id;               /* in: CDF identifier */
  765. void      *var_name;           /* in: attribute name
  766.                        - in VMS may be passed by reference
  767.                      or descriptor */
  768. long      *data_type;            /* in: CDF Version 2 style data type */
  769. long      *num_elements;    /* in: number of elements of data_type; should
  770.                     be 1 if not CDF_CHAR or CDF_UCHAR */
  771. long      *record_variance;     /* in: record variance */
  772. long      dim_variances[];      /* in: dimension variances */
  773. long      *var_num;            /* out: variable number, indexed from 1
  774.                     (FORTRAN style) */
  775. CDFstatus *Status;        /* out: CDF status code */
  776. {
  777. long    varNum;        /* indexed from 0 (V2/C style) */
  778.  
  779. *Status = CDFlib (SELECT_, CDF_, *id,
  780.           CREATE_, VAR_, DESCRtoREFnul(var_name,CDF_VAR_NAME_LEN),
  781.                      *data_type, *num_elements,
  782.                  *record_variance, dim_variances, &varNum,
  783.           NULL_);
  784. *var_num = varNum + 1;            /* indexed from 1 (FORTRAN style) */
  785.  
  786. return;
  787. }
  788. #endif
  789.  
  790. /*****************************************************************************/
  791.  
  792. #if defined(unix)
  793. #if defined(AIX)
  794. void cdf_var_create (id, var_name, data_type, num_elements, record_variance,
  795.              dim_variances, var_num, Status, var_name_len)
  796. #else
  797. void cdf_var_create_ (id, var_name, data_type, num_elements, record_variance,
  798.               dim_variances, var_num, Status, var_name_len)
  799. #endif
  800. CDFid      *id;               /* in: CDF identifier */
  801. char      *var_name;           /* in: attribute name */
  802. long      *data_type;            /* in: CDF Version 2 style data type */
  803. long      *num_elements;    /* in: number of elements of data_type; should
  804.                     be 1 if not CDF_CHAR or CDF_UCHAR */
  805. long      *record_variance;     /* in: record variance */
  806. long      dim_variances[];      /* in: dimension variances */
  807. long      *var_num;            /* out: variable number, indexed from 1
  808.                     (FORTRAN style) */
  809. CDFstatus *Status;        /* out: CDF status code */
  810. long      var_name_len;        /* invisible: length of "var_name"
  811.                    (generated by FORTRAN compiler) */
  812. {
  813. long    varNum;        /* indexed from 0 (V2/C style) */
  814.  
  815. *Status = CDFlib (SELECT_, CDF_, *id,
  816.           CREATE_, VAR_, NULterminate(var_name,var_name_len),
  817.                      *data_type, *num_elements,
  818.                  *record_variance, dim_variances, &varNum,
  819.           NULL_);
  820. *var_num = varNum + 1;            /* indexed from 1 (FORTRAN style) */
  821.  
  822. return;
  823. }
  824. #endif
  825.  
  826.  
  827. /******************************************************************************
  828. *  CDF_var_num.
  829. ******************************************************************************/
  830.  
  831. #if defined(vms)
  832. long CDF_var_num (id, var_name)
  833. CDFid      *id;               /* in: CDF identifier */
  834. void      *var_name;           /* in: variable name
  835.                        - in VMS, may be passed by
  836.                      reference or descriptor */
  837. {
  838. CDFstatus status;
  839. long      varNum;
  840.  
  841. status = CDFlib (SELECT_, CDF_, *id,
  842.          GET_, VAR_NUMBER_, DESCRtoREFnul(var_name,CDF_VAR_NAME_LEN),
  843.                     &varNum,
  844.          NULL_);
  845. if (status < CDF_WARN)
  846.   return status;
  847. else
  848.   return varNum + 1;        /* +1 for FORTRAN i/f (assuming no INFO status
  849.                    codes returned) */
  850. }
  851. #endif
  852.  
  853. /*****************************************************************************/
  854.  
  855. #if defined(unix)
  856. #if defined(AIX)
  857. long cdf_var_num (id, var_name, var_name_len)
  858. #else
  859. long cdf_var_num_ (id, var_name, var_name_len)
  860. #endif
  861. CDFid      *id;               /* in: CDF identifier */
  862. char      *var_name;           /* in: variable name */
  863. long      var_name_len;        /* invisible: length of "var_name"
  864.                    (generated by FORTRAN compiler) */
  865. {
  866. CDFstatus status;
  867. long      varNum;
  868.  
  869. status = CDFlib (SELECT_, CDF_, *id,
  870.          GET_, VAR_NUMBER_, NULterminate(var_name,var_name_len),
  871.                     &varNum,
  872.          NULL_);
  873. if (status < CDF_OK)
  874.   return status;
  875. else
  876.   return varNum + 1;        /* +1 for FORTRAN i/f (assuming no INFO status
  877.                    codes returned) */
  878. }
  879. #endif
  880.  
  881.  
  882. /******************************************************************************
  883. *  CDF_var_rename.
  884. ******************************************************************************/
  885.  
  886. #if defined(vms)
  887. void CDF_var_rename (id, var_num, var_name, Status)
  888. CDFid      *id;            /* in: CDF identifier */
  889. long      *var_num;           /* in: variable number, indexed from 1
  890.                        (FORTRAN style) */
  891. void      *var_name;           /* in: new variable name
  892.                        - in VMS, may be passed by
  893.                      reference or descriptor */
  894. CDFstatus *Status;        /* out: CDF status code */
  895. {
  896. *Status = CDFlib (SELECT_, CDF_, *id,
  897.                VAR_, *var_num - 1,
  898.           PUT_, VAR_NAME_, DESCRtoREFnul(var_name,
  899.                          CDF_VAR_NAME_LEN),
  900.           NULL_);
  901. return;
  902. }
  903. #endif
  904.  
  905. /*****************************************************************************/
  906.  
  907. #if defined(unix)
  908. #if defined(AIX)
  909. void cdf_var_rename (id, var_num, var_name, Status, var_name_len)
  910. #else
  911. void cdf_var_rename_ (id, var_num, var_name, Status, var_name_len)
  912. #endif
  913. CDFid      *id;            /* in: CDF identifier */
  914. long      *var_num;           /* in: variable number, indexed from 1
  915.                        (FORTRAN style) */
  916. char      *var_name;           /* in: new variable name */
  917. CDFstatus *Status;        /* out: CDF status code */
  918. long      var_name_len;        /* invisible: length of "var_name"
  919.                    (generated by FORTRAN compiler) */
  920. {
  921. *Status = CDFlib (SELECT_, CDF_, *id,
  922.                VAR_, *var_num - 1,
  923.           PUT_, VAR_NAME_, NULterminate(var_name,var_name_len),
  924.           NULL_);
  925. return;
  926. }
  927. #endif
  928.  
  929.  
  930. /******************************************************************************
  931. *  CDF_var_inquire.
  932. ******************************************************************************/
  933.  
  934. #if defined(vms)
  935. void CDF_var_inquire (id, var_num, var_name, data_type, num_elements,
  936.               record_variance, dim_variances, Status)
  937. CDFid      *id;                /* in: CDF identifier */
  938. long      *var_num;            /* in: variable number, indexed from 1
  939.                        (FORTRAN style) */
  940. char      *var_name;            /* out: variable name - always passed out
  941.                         by reference */
  942. long      *data_type;            /* out: CDF Version 2 style data type */
  943. long      *num_elements;    /* out: number of elements of data_type */
  944. long      *record_variance;     /* out: record variance */
  945. long      dim_variances[];     /* out: dimension variances */
  946. CDFstatus *Status;        /* out: CDF status code */
  947. {
  948. char    varName[CDF_VAR_NAME_LEN + 1];
  949.  
  950. *Status = CDFlib (SELECT_, CDF_, *id,
  951.                VAR_, *var_num - 1,
  952.           GET_, VAR_NAME_, varName,
  953.             VAR_DATATYPE_, data_type,
  954.             VAR_NUMELEMS_, num_elements,
  955.             VAR_RECVARY_, record_variance,
  956.             VAR_DIMVARYS_, dim_variances,
  957.           NULL_);
  958. if (*Status > CDF_WARN) CtoFORTstring (varName, var_name, CDF_VAR_NAME_LEN);
  959.  
  960. return;
  961. }
  962. #endif
  963.  
  964. /*****************************************************************************/
  965.  
  966. #if defined(unix)
  967. #if defined(AIX)
  968. void cdf_var_inquire (id, var_num, var_name, data_type, num_elements,
  969.               record_variance, dim_variances, Status, var_name_len)
  970. #else
  971. void cdf_var_inquire_ (id, var_num, var_name, data_type, num_elements,
  972.                record_variance, dim_variances, Status, var_name_len)
  973. #endif
  974. CDFid      *id;                /* in: CDF identifier */
  975. long      *var_num;            /* in: variable number, indexed from 1
  976.                        (FORTRAN style) */
  977. char      *var_name;            /* out: variable name */
  978. long      *data_type;            /* out: CDF Version 2 style data type */
  979. long      *num_elements;    /* out: number of elements of data_type */
  980. long      *record_variance;     /* out: record variance */
  981. long      dim_variances[];     /* out: dimension variances */
  982. CDFstatus *Status;        /* out: CDF status code */
  983. long      var_name_len;        /* invisible: length of "var_name"
  984.                    (generated by FORTRAN compiler) */
  985. {
  986. char    varName[CDF_VAR_NAME_LEN + 1];
  987.  
  988. *Status = CDFlib (SELECT_, CDF_, *id,
  989.                VAR_, *var_num - 1,
  990.           GET_, VAR_NAME_, varName,
  991.             VAR_DATATYPE_, data_type,
  992.             VAR_NUMELEMS_, num_elements,
  993.             VAR_RECVARY_, record_variance,
  994.             VAR_DIMVARYS_, dim_variances,
  995.           NULL_);
  996. if (*Status > CDF_WARN) CtoFORTstring (varName, var_name, var_name_len);
  997.  
  998. return;
  999. }
  1000. #endif
  1001.  
  1002.  
  1003. /******************************************************************************
  1004. *  CDF_var_put.
  1005. ******************************************************************************/
  1006.  
  1007. #if defined(vms)
  1008. void CDF_var_put (id, var_num, record_num, indices, value, Status)
  1009. CDFid      *id;                /* in: CDF identifier */
  1010. long      *var_num;            /* in: variable number, indexed from 1
  1011.                        (FORTRAN style) */
  1012. long      *record_num;            /* in: record number, indexed from 1
  1013.                        (FORTRAN style) */
  1014. long      indices[];            /* in: dimension indices, indexed from 1
  1015.                        (FORTRAN style) */
  1016. void      *value;            /* in: variable value, if character data type,
  1017.                        could be passed by reference or by
  1018.                        descriptor */
  1019. CDFstatus *Status;        /* out: CDF status code */
  1020. {
  1021. long    dim_n;
  1022. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1023. long    numDims;
  1024. long    dataType;
  1025.  
  1026. *Status = CDFlib (SELECT_, CDF_, *id,
  1027.                VAR_, *var_num - 1,
  1028.           GET_, CDF_NUMDIMS_, &numDims,
  1029.             VAR_DATATYPE_, &dataType,
  1030.           NULL_);
  1031. if (*Status < CDF_WARN) return;
  1032.  
  1033. for (dim_n = 0; dim_n < numDims; dim_n++)
  1034.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1035.  
  1036. *Status = CDFlib (SELECT_, CDF_, *id,
  1037.                CDF_RECNUMBER_, *record_num - 1,
  1038.                CDF_DIMINDICES_, Cindices,
  1039.           PUT_, VAR_DATA_,
  1040.               STRINGdataType(dataType) ? DESCRtoREF(value) : value,
  1041.           NULL_);
  1042. return;
  1043. }
  1044. #endif
  1045.  
  1046. #if defined(unix)
  1047. #if defined(AIX)
  1048. void cdf_var_put (id, var_num, record_num, indices, value, Status)
  1049. #else
  1050. void cdf_var_put_ (id, var_num, record_num, indices, value, Status)
  1051. #endif
  1052. CDFid      *id;                /* in: CDF identifier */
  1053. long      *var_num;            /* in: variable number, indexed from 1
  1054.                        (FORTRAN style) */
  1055. long      *record_num;            /* in: record number, indexed from 1
  1056.                        (FORTRAN style) */
  1057. long      indices[];            /* in: dimension indices, indexed from 1
  1058.                        (FORTRAN style) */
  1059. void      *value;            /* in: variable value, always passed
  1060.                        by reference */
  1061. CDFstatus *Status;        /* out: CDF status code */
  1062.                 /* invisible: if 'value' is CHARACTER, an
  1063.                           extra argument would have been
  1064.                           passed with its length (ignored
  1065.                           in this case) */
  1066. {
  1067. long    dim_n;
  1068. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1069. long    numDims;
  1070.  
  1071. *Status = CDFlib (SELECT_, CDF_, *id,
  1072.           GET_, CDF_NUMDIMS_, &numDims,
  1073.           NULL_);
  1074. if (*Status < CDF_WARN) return;
  1075.  
  1076. for (dim_n = 0; dim_n < numDims; dim_n++)
  1077.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1078.  
  1079. *Status = CDFlib (SELECT_, CDF_, *id,
  1080.                VAR_, *var_num - 1,
  1081.                CDF_RECNUMBER_, *record_num - 1,
  1082.                CDF_DIMINDICES_, Cindices,
  1083.           PUT_, VAR_DATA_, value,
  1084.           NULL_);
  1085. return;
  1086. }
  1087. #endif
  1088.  
  1089.  
  1090. /******************************************************************************
  1091. *  CDF_var_get.
  1092. ******************************************************************************/
  1093.  
  1094. #if defined(vms)
  1095. void CDF_var_get (id, var_num, record_num, indices, value, Status)
  1096. CDFid      *id;                /* in: CDF identifier */
  1097. long      *var_num;            /* in: variable number, indexed from 1
  1098.                        (FORTRAN style) */
  1099. long      *record_num;            /* in: record number, indexed from 1
  1100.                        (FORTRAN style) */
  1101. long      indices[];            /* in: dimension indices, indexed from 1
  1102.                        (FORTRAN style) */
  1103. void      *value;            /* in: variable value, if character data type,
  1104.                        could be passed by reference or by
  1105.                        descriptor */
  1106. CDFstatus *Status;        /* out: CDF status code */
  1107. {
  1108. long    dim_n;
  1109. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1110. long    numDims;
  1111. long    dataType;
  1112.  
  1113. *Status = CDFlib (SELECT_, CDF_, *id,
  1114.                VAR_, *var_num - 1,
  1115.           GET_, CDF_NUMDIMS_, &numDims,
  1116.             VAR_DATATYPE_, &dataType,
  1117.           NULL_);
  1118. if (*Status < CDF_WARN) return;
  1119.  
  1120. for (dim_n = 0; dim_n < numDims; dim_n++)
  1121.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1122.  
  1123. *Status = CDFlib (SELECT_, CDF_, *id,
  1124.                CDF_RECNUMBER_, *record_num - 1,
  1125.                CDF_DIMINDICES_, Cindices,
  1126.           GET_, VAR_DATA_,
  1127.               STRINGdataType(dataType) ? DESCRtoREF(value) : value,
  1128.           NULL_);
  1129. return;
  1130. }
  1131. #endif
  1132.  
  1133. #if defined(unix)
  1134. #if defined(AIX)
  1135. void cdf_var_get (id, var_num, record_num, indices, value, Status)
  1136. #else
  1137. void cdf_var_get_ (id, var_num, record_num, indices, value, Status)
  1138. #endif
  1139. CDFid      *id;                /* in: CDF identifier */
  1140. long      *var_num;            /* in: variable number, indexed from 1
  1141.                        (FORTRAN style) */
  1142. long      *record_num;            /* in: record number, indexed from 1
  1143.                        (FORTRAN style) */
  1144. long      indices[];            /* in: dimension indices, indexed from 1
  1145.                        (FORTRAN style) */
  1146. void      *value;            /* in: variable value, always passed
  1147.                        by reference */
  1148. CDFstatus *Status;        /* out: CDF status code */
  1149.                 /* invisible: if 'value' is CHARACTER, an
  1150.                           extra argument would have been
  1151.                           passed with its length (ignored
  1152.                           in this case) */
  1153. {
  1154. long    dim_n;
  1155. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1156. long    numDims;
  1157.  
  1158. *Status = CDFlib (SELECT_, CDF_, *id,
  1159.           GET_, CDF_NUMDIMS_, &numDims,
  1160.           NULL_);
  1161. if (*Status < CDF_WARN) return;
  1162.  
  1163. for (dim_n = 0; dim_n < numDims; dim_n++)
  1164.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1165.  
  1166. *Status = CDFlib (SELECT_, CDF_, *id,
  1167.                VAR_, *var_num - 1,
  1168.                CDF_RECNUMBER_, *record_num - 1,
  1169.                CDF_DIMINDICES_, Cindices,
  1170.           GET_, VAR_DATA_, value,
  1171.           NULL_);
  1172. return;
  1173. }
  1174. #endif
  1175.  
  1176.  
  1177. /******************************************************************************
  1178. *  CDF_var_hyper_put.
  1179. ******************************************************************************/
  1180.  
  1181. #if defined(vms)
  1182. void CDF_var_hyper_put (id, var_num,
  1183.             record_start, record_count, record_interval,
  1184.             indices, counts, intervals, buffer, Status)
  1185. CDFid      *id;                /* in: CDF identifier */
  1186. long      *var_num;            /* in: variable number, indexed from 1
  1187.                        (FORTRAN style) */
  1188. long      *record_start;        /* in: starting record number, indexed
  1189.                        from 1 (FORTRAN style) */
  1190. long      *record_count;        /* in: record count */
  1191. long      *record_interval;     /* in: record interval */
  1192. long      indices[];            /* in: dimension indices, indexed from 1
  1193.                        (FORTRAN style) */
  1194. long      counts[];            /* in: dimension counts */
  1195. long      intervals[];            /* in: dimension intervals */
  1196. void      *buffer;            /* in: pointer to buffer of values, if variable
  1197.                        is character data type, could be passed
  1198.                        by reference or descriptor */
  1199. CDFstatus *Status;        /* out: CDF status code */
  1200. {
  1201. long    dim_n;
  1202. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1203. long    numDims;
  1204. long    dataType;
  1205.  
  1206. *Status = CDFlib (SELECT_, CDF_, *id,
  1207.                VAR_, *var_num - 1,
  1208.           GET_, CDF_NUMDIMS_, &numDims,
  1209.             VAR_DATATYPE_, &dataType,
  1210.           NULL_);
  1211. if (*Status < CDF_WARN) return;
  1212.  
  1213. for (dim_n = 0; dim_n < numDims; dim_n++)
  1214.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1215.  
  1216. *Status = CDFlib (SELECT_, CDF_, *id,
  1217.                CDF_RECNUMBER_, *record_start - 1,
  1218.                CDF_RECCOUNT_, *record_count,
  1219.                CDF_RECINTERVAL_, *record_interval,
  1220.                CDF_DIMINDICES_, Cindices,
  1221.                CDF_DIMCOUNTS_, counts,
  1222.                CDF_DIMINTERVALS_, intervals,
  1223.           PUT_, VAR_HYPERDATA_, STRINGdataType(dataType) ?
  1224.                         DESCRtoREF(buffer) : buffer,
  1225.           NULL_);
  1226. return;
  1227. }
  1228. #endif
  1229.  
  1230. #if defined(unix)
  1231. #if defined(AIX)
  1232. void cdf_var_hyper_put (id, var_num,
  1233.             record_start, record_count, record_interval,
  1234.             indices, counts, intervals, buffer, Status)
  1235. #else
  1236. void cdf_var_hyper_put_ (id, var_num,
  1237.              record_start, record_count, record_interval,
  1238.              indices, counts, intervals, buffer, Status)
  1239. #endif
  1240. CDFid      *id;                /* in: CDF identifier */
  1241. long      *var_num;            /* in: variable number, indexed from 1
  1242.                        (FORTRAN style) */
  1243. long      *record_start;        /* in: starting record number, indexed
  1244.                        from 1 (FORTRAN style) */
  1245. long      *record_count;        /* in: record count */
  1246. long      *record_interval;     /* in: record interval */
  1247. long      indices[];            /* in: dimension indices, indexed from 1
  1248.                        (FORTRAN style) */
  1249. long      counts[];            /* in: dimension counts */
  1250. long      intervals[];            /* in: dimension intervals */
  1251. void      *buffer;            /* in: pointer to buffer of values, always
  1252.                        passed by reference */
  1253. CDFstatus *Status;        /* out: CDF status code */
  1254.                 /* invisible: if 'buffer' is CHARACTER, an
  1255.                           extra argument would have been
  1256.                           passed with its length (ignored
  1257.                           in this case) */
  1258. {
  1259. long    dim_n;
  1260. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1261. long    numDims;
  1262.  
  1263. *Status = CDFlib (SELECT_, CDF_, *id,
  1264.           GET_, CDF_NUMDIMS_, &numDims,
  1265.           NULL_);
  1266. if (*Status < CDF_WARN) return;
  1267.  
  1268. for (dim_n = 0; dim_n < numDims; dim_n++)
  1269.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1270.  
  1271. *Status = CDFlib (SELECT_, CDF_, *id,
  1272.                VAR_, *var_num - 1,
  1273.                CDF_RECNUMBER_, *record_start - 1,
  1274.                CDF_RECCOUNT_, *record_count,
  1275.                CDF_RECINTERVAL_, *record_interval,
  1276.                CDF_DIMINDICES_, Cindices,
  1277.                CDF_DIMCOUNTS_, counts,
  1278.                CDF_DIMINTERVALS_, intervals,
  1279.           PUT_, VAR_HYPERDATA_, buffer,
  1280.           NULL_);
  1281. return;
  1282. }
  1283. #endif
  1284.  
  1285.  
  1286. /******************************************************************************
  1287. *  CDF_var_hyper_get.
  1288. ******************************************************************************/
  1289.  
  1290. #if defined(vms)
  1291. void CDF_var_hyper_get (id, var_num,
  1292.             record_start, record_count, record_interval,
  1293.             indices, counts, intervals, buffer, Status)
  1294. CDFid      *id;                /* in: CDF identifier */
  1295. long      *var_num;            /* in: variable number, indexed from 1
  1296.                        (FORTRAN style) */
  1297. long      *record_start;        /* in: starting record number, indexed
  1298.                        from 1 (FORTRAN style) */
  1299. long      *record_count;        /* in: record count */
  1300. long      *record_interval;     /* in: record interval */
  1301. long      indices[];            /* in: dimension indices, indexed from 1
  1302.                        (FORTRAN style) */
  1303. long      counts[];            /* in: dimension counts */
  1304. long      intervals[];            /* in: dimension intervals */
  1305. void      *buffer;            /* in: pointer to buffer of values, if variable
  1306.                        is character data type, could be passed
  1307.                        by reference or descriptor */
  1308. CDFstatus *Status;        /* out: CDF status code */
  1309. {
  1310. long    dim_n;
  1311. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1312. long    numDims;
  1313. long    dataType;
  1314.  
  1315. *Status = CDFlib (SELECT_, CDF_, *id,
  1316.                VAR_, *var_num - 1,
  1317.           GET_, CDF_NUMDIMS_, &numDims,
  1318.             VAR_DATATYPE_, &dataType,
  1319.           NULL_);
  1320. if (*Status < CDF_WARN) return;
  1321.  
  1322. for (dim_n = 0; dim_n < numDims; dim_n++)
  1323.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1324.  
  1325. *Status = CDFlib (SELECT_, CDF_, *id,
  1326.                CDF_RECNUMBER_, *record_start - 1,
  1327.                CDF_RECCOUNT_, *record_count,
  1328.                CDF_RECINTERVAL_, *record_interval,
  1329.                CDF_DIMINDICES_, Cindices,
  1330.                CDF_DIMCOUNTS_, counts,
  1331.                CDF_DIMINTERVALS_, intervals,
  1332.           GET_, VAR_HYPERDATA_, STRINGdataType(dataType) ?
  1333.                         DESCRtoREF(buffer) : buffer,
  1334.           NULL_);
  1335. return;
  1336. }
  1337. #endif
  1338.  
  1339. #if defined(unix)
  1340. #if defined(AIX)
  1341. void cdf_var_hyper_get (id, var_num,
  1342.             record_start, record_count, record_interval,
  1343.             indices, counts, intervals, buffer, Status)
  1344. #else
  1345. void cdf_var_hyper_get_ (id, var_num,
  1346.              record_start, record_count, record_interval,
  1347.              indices, counts, intervals, buffer, Status)
  1348. #endif
  1349. CDFid      *id;                /* in: CDF identifier */
  1350. long      *var_num;            /* in: variable number, indexed from 1
  1351.                        (FORTRAN style) */
  1352. long      *record_start;        /* in: starting record number, indexed
  1353.                        from 1 (FORTRAN style) */
  1354. long      *record_count;        /* in: record count */
  1355. long      *record_interval;     /* in: record interval */
  1356. long      indices[];            /* in: dimension indices, indexed from 1
  1357.                        (FORTRAN style) */
  1358. long      counts[];            /* in: dimension counts */
  1359. long      intervals[];            /* in: dimension intervals */
  1360. void      *buffer;            /* in: pointer to buffer of values, always
  1361.                        passed by reference */
  1362. CDFstatus *Status;        /* out: CDF status code */
  1363.                 /* invisible: if 'buffer' is CHARACTER, an
  1364.                           extra argument would have been
  1365.                           passed with its length (ignored
  1366.                           in this case) */
  1367. {
  1368. long    dim_n;
  1369. long    Cindices[CDF_MAX_DIMS];        /* indexed from 0 (V2/C-style) */
  1370. long    numDims;
  1371.  
  1372. *Status = CDFlib (SELECT_, CDF_, *id,
  1373.           GET_, CDF_NUMDIMS_, &numDims,
  1374.           NULL_);
  1375. if (*Status < CDF_WARN) return;
  1376.  
  1377. for (dim_n = 0; dim_n < numDims; dim_n++)
  1378.    Cindices[dim_n] = indices[dim_n] - 1;    /* index from 0 */
  1379.  
  1380. *Status = CDFlib (SELECT_, CDF_, *id,
  1381.                VAR_, *var_num - 1,
  1382.                CDF_RECNUMBER_, *record_start - 1,
  1383.                CDF_RECCOUNT_, *record_count,
  1384.                CDF_RECINTERVAL_, *record_interval,
  1385.                CDF_DIMINDICES_, Cindices,
  1386.                CDF_DIMCOUNTS_, counts,
  1387.                CDF_DIMINTERVALS_, intervals,
  1388.           GET_, VAR_HYPERDATA_, buffer,
  1389.           NULL_);
  1390. return;
  1391. }
  1392. #endif
  1393.  
  1394.  
  1395. /******************************************************************************
  1396. *  CDF_var_close.
  1397. ******************************************************************************/
  1398.  
  1399. #if defined(vms)
  1400. void CDF_var_close (id, var_num, Status)
  1401. #endif
  1402.  
  1403. #if defined(unix)
  1404. #if defined(AIX)
  1405. void cdf_var_close (id, var_num, Status)
  1406. #else
  1407. void cdf_var_close_ (id, var_num, Status)
  1408. #endif
  1409. #endif
  1410.  
  1411. CDFid      *id;                /* in: CDF identifier */
  1412. long      *var_num;            /* in: variable number, indexed from 1
  1413.                        (FORTRAN style) */
  1414. CDFstatus *Status;        /* out: CDF status code */
  1415. {
  1416. *Status = CDFlib (SELECT_, CDF_, *id,
  1417.                      VAR_, *var_num - 1,
  1418.           CLOSE_, VAR_,
  1419.           NULL_);
  1420. return;
  1421. }
  1422.  
  1423.  
  1424. /******************************************************************************
  1425. *  CDF_error.
  1426. ******************************************************************************/
  1427.  
  1428. #if defined(vms)
  1429. void CDF_error (Status, text)
  1430. CDFstatus *Status;        /* in: CDF status code */
  1431. char      *text;        /* out: character string to receive
  1432.                     explaination, passed out by reference
  1433.                     or descriptor */
  1434. {
  1435. char      statusText[CDF_ERRTEXT_LEN + 1];
  1436. CDFstatus status;
  1437.  
  1438. status = CDFlib (SELECT_, CDF_STATUS_, *Status,
  1439.          GET_, STATUS_TEXT_, statusText,
  1440.          NULL_);
  1441. if (status > CDF_WARN)
  1442.   CtoFORTstring (statusText, text, CDF_STATUSTEXT_LEN)
  1443. else
  1444.   CtoFORTstring ("Unknown CDFstatus", text, CDF_STATUSTEXT_LEN)
  1445.  
  1446. return;
  1447. }
  1448. #endif
  1449.  
  1450. /*****************************************************************************/
  1451.  
  1452. #if defined(unix)
  1453. #if defined(AIX)
  1454. void cdf_error (Status, text, text_len)
  1455. #else
  1456. void cdf_error_ (Status, text, text_len)
  1457. #endif
  1458. CDFstatus *Status;        /* in: CDF status code */
  1459. char      *text;        /* out: character string to receive
  1460.                     explaination */
  1461. long      text_len;        /* invisible: length of "text" (generated by
  1462.                    the FORTRAN compiler) */
  1463. {
  1464. char      errorText[CDF_STATUSTEXT_LEN + 1];
  1465. CDFstatus status;
  1466.  
  1467. status = CDFlib (SELECT_, CDF_STATUS_, *Status,
  1468.          GET_, STATUS_TEXT_, errorText,
  1469.          NULL_);
  1470. if (status > CDF_WARN)
  1471.   CtoFORTstring (errorText, text, text_len)
  1472. else
  1473.   CtoFORTstring ("Unknown CDFstatus", text, text_len)
  1474.  
  1475. return;
  1476. }
  1477. #endif
  1478.